package com.java.user.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.java.constants.UserConstants;
import com.java.param.PageParam;
import com.java.param.UserCheckParam;
import com.java.param.UserLoginParam;
import com.java.pojo.User;
import com.java.user.mapper.UserMapper;
import com.java.user.service.UserService;
import com.java.utils.MD5Util;
import com.java.utils.R;
import com.sun.corba.se.impl.oa.toa.TOA;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.validation.BindingResult;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;

import java.util.List;

@Service
@Slf4j
public class UserServiceImpl implements UserService {
    @Autowired
    private UserMapper userMapper;

    /**
     *  检查账号是否可用业务
     * @param userCheckParam 账号参数 已经检验完毕
     * @return 检查结果 001 004
     */
    @Override
    public R check(UserCheckParam userCheckParam) {

        //参数封装
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("user_name",userCheckParam.getUserName());
        //数组库查询
        Long total = userMapper.selectCount(queryWrapper);

        //查询结果处理
        if(total==0){
            log.info("UserServiceImpl.check业务结束，结果{账号可以使用}");
            return R.ok("账号不存在，可以使用！");
        }
        log.info("UserServiceImpl.check业务结束，结果{账号存在，账号不可以使用}");
        return R.fail("账号已存在，不可以使用");
    }

    /**
     * 用户注册
     * @param user
     * @return
     */
    @Override
    public R register(User user) {
        //1.检查账号是否存在
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("user_name",user.getUserName());
        Long total = userMapper.selectCount(queryWrapper);
        if(total > 0){
            log.info("账号已存在，注册失败");
            return R.fail("账号已存在，注册失败！");
        }
        //2.密码进行加密
        //加盐处理
        /*MD5加密 一种不可逆转的加密方式，只能加密不能解密
        固定明文加密以后的密文是固定的
        可被暴力破解
        解决方法：1.提高用户密码复杂度
        2.加盐处理 用户密码 1 + 字符串 9999 = 10000
        *
        * */
        String newPwd = MD5Util.encode(user.getPassword()+ UserConstants.USER_SLAT);
        user.setPassword(newPwd);
        //3.插入到数据库中
        int rows = userMapper.insert(user);
        //4.返回结果信息
        if(rows==0){
            log.info("插入数据库失败");
            return R.fail("注册失败！");
        }

        log.info("注册成功！");
        return R.ok("注册成功！");
    }

    /**
     * 登录业务
     *
     * @param userLoginParam 用户名和密码，密码未加密
     * @return
     */
    @Override
    public R login(UserLoginParam userLoginParam) {
        //1.密码加密
        String newPwd = MD5Util.encode(userLoginParam.getPassword() + UserConstants.USER_SLAT);
        userLoginParam.setPassword(newPwd);
        //查询数据库账号密码是否匹配
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("user_name",userLoginParam.getUserName());
        queryWrapper.eq("password",userLoginParam.getPassword());
        //System.out.println(queryWrapper);
        //System.out.println(userLoginParam.getUserName()+""+userLoginParam.getPassword());
        User user = userMapper.selectOne(queryWrapper);
        if(user == null){
            log.info("登陆失败，账号或密码错误！");
            return R.fail("账号或密码错误！");
        }
        //处理密码，不回显
        user.setPassword(null);
        //返回登录信息
        log.info("登陆成功！");
        return R.ok("登陆成功！",user);
    }

    /**
     * 根据分页查询用户信息
     *
     * @param pageParam
     * @return
     */
    @Override
    public R listPage(PageParam pageParam) {

        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.orderByDesc("user_id");
        IPage<User> page = new Page<>(pageParam.getCurrentPage(),pageParam.getPageSize());
        page  = userMapper.selectPage(page,queryWrapper);
        List<User> records = page.getRecords();
        long total = page.getTotal();
        log.info("UserServiceImpl.listPage 业务已经完成,结果:{}", records, total);
        return R.ok("查询用户信息成功！",records,total);
    }

    /**
     * 根据userid 删除用户
     *
     * @param userId
     * @return
     */
    @Override
    public R userRemove(Integer userId) {
        int rows = userMapper.deleteById(userId);
        if(rows==0){
            return R.fail("删除用户数据失败！");
        }
        return R.ok("删除用户数据成功！");
    }

    /**
     * 修改用户信息
     *
     * @param user
     * @return
     */
    @Override
    public R update(User user) {

        //账号和id不修改
        //判断用户密码是否和数据库密码一致（即未修改）
        User user1 = userMapper.selectById(user.getUserId());
        if(!user1.getPassword().equals(user.getPassword())){
            String newPassword = MD5Util.encode(user.getPassword() + UserConstants.USER_SLAT);
            user.setPassword(newPassword);
        }
        int rows = userMapper.updateById(user);
        if(rows==0){
            return R.fail("更新用户信息失败！");
        }
        return R.ok("更新用户信息成功！");
    }

    /**
     * 添加用户
     *
     * @param user
     * @return
     */
    @Override
    public R save(User user) {
        //1.检查账号是否存在
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("user_name",user.getUserName());
        Long total = userMapper.selectCount(queryWrapper);
        if(total > 0){
            log.info("账号已存在，无法添加用户");
            return R.fail("账号已存在，无法添加用户！");
        }
        user.setPassword(MD5Util.encode(user.getPassword()+UserConstants.USER_SLAT));
        int rows = userMapper.insert(user);
        if(rows==0){
            return R.fail("用户添加失败！");
        }
        return R.ok("用户添加成功");
    }
}
